home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / ohelp.bbq < prev    next >
Text File  |  2000-09-26  |  27KB  |  1,215 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                     ATUtilities Online Help                   ** */
  4. /* **            Copright (C) 1992-1993 by Thomas Dreibholz         ** */
  5. /* **                      All rights reserved                      ** */
  6. /* **                                                               ** */
  7. /* ******************************************************************* */
  8.  
  9. #define PAGE_INDEX 1
  10. #define PAGE_TEXT  2
  11. #define ZEILEN     25
  12.  
  13. #include "ATUtilities.h"
  14. /*
  15. #define CreateBoolGadget(win,x,y,w,h,text,id) CreateBoolToggleGadget(0,win,x,y,w,h,text,id)
  16. #define CreateMinGadget(win,x,y,w,h,id) CreateBoolToggleGadget(4,win,x,y,w,h,0L,id)
  17. */
  18. extern struct Library *DiskfontBase;
  19.  
  20.  
  21. /* feste Strukturen */
  22. UWORD Strings=66;
  23. UBYTE *String[]=
  24. {
  25.  "",
  26.  "\x9b1;33;40mBedienung des Online-Hilfesystems\x9b0;33;40m",
  27.  "",
  28.  "",
  29.  "\x9b4;33;40mAuswahl von Seiten\x9b0;33;40m",
  30.  "",
  31.  "Beim Aufruf des Hilfesystems wird zuerst der Hauptindex geladen. Durch",
  32.  "Klicken auf die Gadgets im Index gelangt man zu den entsprechenden",
  33.  "Seiten.",
  34.  "",
  35.  "Am unteren Bildschirmrand befindet sich mindestens ein Gadget; maximal",
  36.  "jedoch vier. Mit ihnen kann zur nächsten bzw. vorhergehenden Seite ge-",
  37.  "wechselt werden.",
  38.  "",
  39.  "Gadget-Positionen und ihre Funktionen",
  40.  "",
  41.  "[Vorherg. Index]  [Vorherg. Texts.] [Nächste Texts.]  [Nächster Index]",
  42.  "",
  43.  "",
  44.  "\x9b4;33;40mSeitentypen\x9b0;33;40m",
  45.  "",
  46.  "",
  47.  "Indexseiten"
  48.  "",
  49.  "Auf Indexseiten befinden sich Gadgets, die zu den entsprechenden Text-",
  50.  "seiten führen.",
  51.  "",
  52.  "",
  53.  "Textseiten",
  54.  "",
  55.  "Auf diesen Seiten stehen die Hilfstexte. Ist der Text größer als der",
  56.  "im Textfenster zur Verfügung stehende Platz, so läßt sich der Text-",
  57.  "ausschnitt mit dem Proportional-Gadget am rechten Bildschirmrand ver-",
  58.  "schieben.",
  59.  "Besitzt die Seite Querverweise auf andere Seiten, so sind diese im",
  60.  "Menü \"Querverweise\" aufgelistet. Durch Anwahl des entsprechenden",
  61.  "Menüpunktes wird die Seite geladen.",
  62.  "Gleiches gilt für Bilder und Diagramme im Menü \"Bilder\".",
  63.  "",
  64.  "",
  65.  "\x9b4;33;40mDas Datei-Menü\x9b0;33;40m",
  66.  "",
  67.  "",
  68.  "Der Menüpunkt \"Einstellungen ändern\"",
  69.  "",
  70.  "Hier lassen sich die Grundeinstellungen des Hilfesystems ändern:",
  71.  "Cache-Modus: Die Hilfedatei wird beim Start komplett in den Haupt-",
  72.  "             speicher geladen. Bei Systemen mit wenig Speicher kann",
  73.  "             der Modus ausgeschaltet werden. Bei jeder neuen Seite",
  74.  "             wird dann vom Datenträger nachgeladen."
  75.  "",
  76.  "",
  77.  "Der Menüpunkt \"Bedienungshinweise\"",
  78.  "",
  79.  "Hiermit wird dieser Text angezeigt.",
  80.  "",
  81.  "",
  82.  "Der Menüpunkt \"Information\"",
  83.  "",
  84.  "Hiermit werden Informationen über das Hilfesystem, die Version und",
  85.  "den noch freien Speicher im Amiga und auf einer eventuell vorhan-",
  86.  "denen PC/AT-Brückenkarte angezeigt.",
  87.  "",
  88.  "",
  89.  "Der Menüpunkt \"Hilfe beenden\"",
  90.  "",
  91.  "Hiermit wird das Hilfesystem geschlossen und in das Anwendungs-",
  92.  "programm zurückgekehrt."
  93. };
  94.  
  95. struct TextAttr Opal=
  96. {
  97.  "opal.font",
  98.  9,
  99.  FS_NORMAL,
  100.  FPF_DISKFONT
  101. };
  102.  
  103. struct NewScreen HelpScreen=
  104. {
  105.  0,0,640,256,3,
  106.  0,1,
  107.  HIRES,
  108.  CUSTOMSCREEN,
  109.  NULL,
  110.  NULL,NULL,NULL
  111. };
  112.  
  113. struct Page
  114. {
  115.  UWORD Length;
  116.  UWORD Flags;
  117.  ULONG Offset;
  118.  ULONG TextOffset;
  119.  ULONG GadgetOffset;
  120. };
  121.  
  122. struct Pages
  123. {
  124.  struct Page Page[1000];
  125. };
  126.  
  127. #define GOFFSET(x) hd->Pages->Page[x].GadgetOffset
  128. #define TOFFSET(x) hd->Pages->Page[x].TextOffset
  129. #define OFFSET(x) hd->Pages->Page[x].Offset
  130. #define LENGTH(x) hd->Pages->Page[x].Length
  131. #define FLAGS(x) hd->Pages->Page[x].Flags
  132.  
  133. struct HelpData
  134. {
  135.  struct Screen     *Screen;
  136.  struct Window     *MainWindow;
  137.  struct Window     *IndexWindow;
  138.  struct Window     *TextWindow;
  139.  struct MenuStrip  *MenuStrip;
  140.  struct Menu       *DateiMenu;
  141.  struct Menu       *QVMenu;
  142.  struct Menu       *BilderMenu;
  143.  struct Window     *GadWindow;
  144.  struct Gadget     *PropGadget;
  145.  struct PropInfo   *PropInfo;
  146.  struct RastPort   *MainRastPort;
  147.  struct RastPort   *IndexRastPort;
  148.  struct MsgPort    *MainUserPort;
  149.  struct MsgPort    *IndexUserPort;
  150.  struct MsgPort    *TextUserPort;
  151.  struct MsgPort    *GadUserPort;
  152.  struct TextFont   *OpalFont;
  153.  struct ViewPort   *ViewPort;
  154.  struct MsgPort    *ConPort;
  155.  struct IOStdReq   *ConReq;
  156.  LONG               ConDev;
  157.  struct FileHandle *HelpFile;
  158.  UBYTE             *Memory;
  159.  struct Pages      *Pages;
  160.  UWORD              Page;
  161.  UWORD              Flags;
  162.  ULONG              MainWindowSM;
  163.  ULONG              IndexWindowSM;
  164.  ULONG              TextWindowSM;
  165.  ULONG              GadWindowSM;
  166.  ULONG              WaitSM;
  167.  UWORD              NextPage[4];
  168.  
  169.  UWORD              IGy;
  170.  UWORD              IGw;
  171.  UWORD              IGs;
  172.  UWORD              IGPCount;
  173.  struct Gadget     *IndexGadgets[64];
  174.  UWORD              IndexGadgetPages[64];
  175.  
  176.  UWORD              MenuPageCount;
  177.  UWORD              MenuNames[25][70];
  178.  UWORD              MenuPages[25];
  179.  
  180.  UWORD              PropBody;
  181.  UWORD              LineCount;
  182.  UWORD              CurrentLine;
  183.  UBYTE             *Lines[2000];
  184. }; 
  185.  
  186. UWORD Colors[]={0x97a,0x222,0xddd,0xff5,0xdd6,0xccc,0xfff,0x22f};
  187.  
  188. BOOL OpenHelp();
  189. VOID CloseHelp();
  190. VOID ConWrite();
  191. VOID RefreshGadWindow();
  192. VOID GetTitle();
  193. VOID LoadPage();
  194. VOID ShowIndexPage();
  195. VOID ShowTextPage();
  196. VOID RemIndexGadgets();
  197. VOID NewProp();
  198. VOID ShowPart();
  199. VOID MakeMenu();
  200. VOID Hinweise();
  201.  
  202. UBYTE *GetOpalLine();
  203. UBYTE *GetOpalLine450();
  204. VOID RemoveMenuStrip();
  205. VOID UseMenuStrip();
  206. struct MenuStrip *BuildMenuStrip();
  207. struct Menu      *AddMenu();
  208. struct Menu      *AddItem();
  209.  
  210.  
  211. /* Informationen anzeigen */
  212. VOID ShowInfo(win,scr)
  213.  struct Window *win;
  214.  struct Screen *scr;
  215. {
  216.  WBenchToFront();
  217.  InformationBox("ATUtilities Online Help - Information",
  218.                 "Online Help - Version 2.0",
  219.                 "Copyright (C) 1993 by",
  220.                 "Thomas Dreibholz",
  221.                 "All rights reserved.",
  222.                 "SYS:PC/ATUtilities/Icons/Help");
  223.  ScreenToFront(scr);
  224.  ActivateWindow(win);
  225. }
  226.  
  227.  
  228. /* Online-Hilfe-Funktion */
  229. VOID Help(name,seite)
  230.  UBYTE *name;
  231.  UWORD  seite;
  232. {
  233.  struct IntuiMessage *msg;
  234.  struct HelpData     *hd;
  235.  struct Gadget       *gad;
  236.  ULONG                Class;
  237.  BOOL                 ende,bool;
  238.  UWORD                i,j,Code;
  239.  UWORD                MenuNum,ItemNum;
  240.  ULONG                Signale;
  241.  
  242.  if(DiskfontBase==NULL)
  243.   {
  244.    InfoRequest("Keine Diskfont-Library!");
  245.    return;
  246.   }
  247.  
  248.  hd=AllocMem(sizeof(struct HelpData),MEMF_CLEAR|MEMF_PUBLIC);
  249.  if(hd==NULL)
  250.   {
  251.    ErrorRequest(ERROR_ALLOC);
  252.    return;
  253.   }
  254.  
  255.  bool=OpenHelp(hd,name);
  256.  if(bool==TRUE)
  257.   {
  258.    ende=FALSE;
  259.    while(ende==FALSE)
  260.     {
  261.      Signale=Wait(hd->WaitSM);
  262.      if((hd->GadUserPort!=NULL) && (Signale & hd->GadWindowSM))
  263.       {
  264.        msg=GetMsg(hd->GadUserPort);
  265.        if(msg!=NULL)
  266.         {
  267.          Class=msg->Class;
  268.          gad=msg->IAddress;
  269.          ReplyMsg(msg);
  270.          if(Class==GADGETUP)
  271.           {
  272.            j=gad->GadgetID;
  273.            LoadPage(hd,hd->NextPage[j]);
  274.           }
  275.          else if(Class==ACTIVEWINDOW)
  276.            ActivateWindow(hd->MainWindow);
  277.         }
  278.       }
  279.      if(Signale & hd->MainWindowSM)
  280.       {
  281.        msg=GetMsg(hd->MainUserPort);
  282.        if(msg!=NULL)
  283.         {
  284.          Class=msg->Class;
  285.          Code=msg->Code;
  286.          gad=msg->IAddress;
  287.          ReplyMsg(msg);
  288.          switch(Class)
  289.           {
  290.            case GADGETUP:
  291.             j=gad->GadgetID;
  292.             switch(j)
  293.              {
  294.               case 1:
  295.                 ende=TRUE;
  296.                break;
  297.               case 2:
  298.                 LoadPage(hd,0);
  299.                break;
  300.               case 3:
  301.                 if(hd->Flags==PAGE_TEXT)
  302.                  {
  303.                   j=hd->PropInfo->VertPot/(65535/hd->PropBody);
  304.                   ShowPart(hd,j);
  305.                  }
  306.                break;
  307.              }
  308.             break;
  309.            case MENUPICK:
  310.              MenuNum=MENUNUM(Code);
  311.              ItemNum=ITEMNUM(Code);
  312.              switch(MenuNum)
  313.               {
  314.                case 2:
  315.                  switch(ItemNum)
  316.                   {
  317.                    case 0:
  318.                      ende=TRUE;
  319.                     break;
  320.                    case 2:
  321.                      ShowInfo(hd->MainWindow,hd->Screen);
  322.                     break;
  323.                    case 3:
  324.                      Hinweise(hd);
  325.                     break;
  326.                   }
  327.                 break;
  328.                case 1:
  329.                  if((hd->MenuPageCount!=0)&&(ItemNum<=hd->MenuPageCount))
  330.                    LoadPage(hd,hd->MenuPages[hd->MenuPageCount-ItemNum-1]);
  331.                 break;
  332.               }
  333.             break;
  334.           }
  335.         }
  336.       }
  337.      if(Signale & hd->IndexWindowSM)
  338.       {
  339.        msg=GetMsg(hd->IndexUserPort);
  340.        if(msg!=NULL)
  341.         {
  342.          Class=msg->Class;
  343.          gad=msg->IAddress;
  344.          ReplyMsg(msg);
  345.          if(Class==GADGETUP)
  346.           {
  347.            j=gad->GadgetID;
  348.            LoadPage(hd,hd->IndexGadgetPages[j]);
  349.           }
  350.          else if(Class==ACTIVEWINDOW)
  351.            ActivateWindow(hd->MainWindow);
  352.         }
  353.       }
  354.      if(Signale & hd->TextWindowSM)
  355.       {
  356.        msg=GetMsg(hd->TextUserPort);
  357.        if(msg!=NULL)
  358.         {
  359.          Class=msg->Class;
  360.          ReplyMsg(msg);
  361.          if(Class==ACTIVEWINDOW)
  362.            ActivateWindow(hd->MainWindow);
  363.         }
  364.       }
  365.     }
  366.   }
  367.  CloseHelp(hd);
  368.  FreeMem(hd,sizeof(struct HelpData));
  369. }
  370.  
  371.  
  372. BOOL OpenHelp(hd,name)
  373.  struct HelpData *hd;
  374.  UBYTE           *name;
  375. {
  376.  UBYTE c;
  377.  WORD  a,i;
  378.  LONG  b;
  379.  static struct NewWindow MainWindowDef=
  380.   {
  381.    0,0,640,256,
  382.    0,2,
  383.    GADGETUP|MENUPICK,
  384.    NOCAREREFRESH|ACTIVATE|BORDERLESS,
  385.    NULL,NULL,NULL,NULL,NULL,
  386.    10,16,640,256,
  387.    CUSTOMSCREEN
  388.   };
  389.  static struct NewWindow IndexWindowDef=
  390.   {
  391.    11,26,582,210,
  392.    0,1,
  393.    GADGETUP|ACTIVEWINDOW,
  394.    BORDERLESS,
  395.    NULL,NULL,NULL,NULL,NULL,
  396.    10,16,640,256,
  397.    CUSTOMSCREEN
  398.   };
  399.  static struct NewWindow TextWindowDef=
  400.   {
  401.    12,27,580,208,
  402.    0,1,
  403.    ACTIVEWINDOW,
  404.    BORDERLESS,
  405.    NULL,NULL,NULL,NULL,NULL,
  406.    10,16,640,256,
  407.    CUSTOMSCREEN
  408.   };
  409.  
  410.  hd->ConDev=-1L;
  411.  
  412.  hd->OpalFont=GetOpalFont();
  413.  if(hd->OpalFont==NULL)
  414.   {
  415.    InfoRequest("Opal-Font fehlt!");
  416.    return(FALSE);
  417.   }
  418.  
  419.  hd->Screen=OpenScreen(&HelpScreen);
  420.  if(hd->Screen==NULL)
  421.   {
  422.    InfoRequest("Kann Screen nicht öffnen!");
  423.    return(FALSE);
  424.   }
  425.  
  426.  hd->ViewPort=&hd->Screen->ViewPort;
  427.  LoadRGB4(hd->ViewPort,&Colors,8);
  428.  
  429.  MainWindowDef.Screen=hd->Screen;
  430.  IndexWindowDef.Screen=hd->Screen;
  431.  TextWindowDef.Screen=hd->Screen;
  432.  
  433.  hd->IndexWindow=OpenWindow(&IndexWindowDef);
  434.  if(hd->IndexWindow==NULL)
  435.   {
  436.    InfoRequest("Kann Fenster nicht öffnen!");
  437.    return(FALSE);
  438.   }
  439.  
  440.  hd->TextWindow=OpenWindow(&TextWindowDef);
  441.  if(hd->TextWindow==NULL)
  442.   {
  443.    InfoRequest("Kann Fenster nicht öffnen!");
  444.    return(FALSE);
  445.   }
  446.  
  447.  hd->MainWindow=OpenWindow(&MainWindowDef);
  448.  if(hd->MainWindow==NULL)
  449.   {
  450.    InfoRequest("Kann Fenster nicht öffnen!");
  451.    return(FALSE);
  452.   }
  453.  
  454.  hd->MainRastPort=hd->MainWindow->RPort;
  455.  hd->IndexRastPort=hd->IndexWindow->RPort;
  456.  hd->MainUserPort=hd->MainWindow->UserPort;
  457.  hd->IndexUserPort=hd->IndexWindow->UserPort;
  458.  hd->TextUserPort=hd->TextWindow->UserPort;
  459.  hd->MainWindowSM=(1L<<hd->MainUserPort->mp_SigBit);
  460.  hd->IndexWindowSM=(1L<<hd->IndexUserPort->mp_SigBit);
  461.  hd->TextWindowSM=(1L<<hd->TextUserPort->mp_SigBit);
  462.  hd->MainWindow->UserData=NULL;
  463.  hd->IndexWindow->UserData=NULL;
  464.  hd->TextWindow->UserData=NULL;
  465.  
  466.  SetFont(hd->MainRastPort,hd->OpalFont);
  467.  SetFont(hd->IndexRastPort,hd->OpalFont);
  468.  
  469.  CreateBoolGadget(hd->MainWindow,10,10,150,12,"Ende",1);
  470.  CreateBoolGadget(hd->MainWindow,165,10,150,12,"Index",2);
  471.  hd->PropGadget=CreatePropGadget(hd->MainWindow,600,25,30,211,0,0,0,(65535/10),3);
  472.  hd->PropInfo=hd->PropGadget->SpecialInfo;
  473.  DrawNBorder(hd->MainWindow,10,25,584,211);
  474.  
  475.  SetAPen(hd->MainRastPort,3);
  476.  WriteText(hd->MainRastPort,40,40,"ATUtilities Online-Hilfe - Version 2.0");
  477.  WriteText(hd->MainRastPort,40,60,"Hilfedatei wird bearbeitet.");
  478.  WriteText(hd->MainRastPort,40,80,"Bitte warten...");
  479.  
  480.  hd->ConPort=CreatePort("onlinehelp-console.port",0L);
  481.  if(hd->ConPort==NULL)
  482.   {
  483.    InfoRequest("Kann MsgPort nicht erstellen!");
  484.    return(FALSE);
  485.   }
  486.  
  487.  hd->ConReq=CreateExtIO(hd->ConPort,sizeof(struct IOStdReq));
  488.  if(hd->ConReq==NULL)
  489.   {
  490.    InfoRequest("Kann IOStdReq nicht erstellen!");
  491.    return(FALSE);
  492.   }
  493.  
  494.  hd->ConReq->io_Data=hd->TextWindow;
  495.  hd->ConReq->io_Length=sizeof(struct Window);
  496.  
  497.  hd->ConDev=OpenDevice("console.device",0L,hd->ConReq,0L);
  498.  if(hd->ConDev!=0)
  499.   {
  500.    InfoRequest("Kann Console-Device nicht öffnen!");
  501.    return(FALSE);
  502.   }
  503.  
  504.  ConWrite(hd,"\x9b");
  505.  ConWrite(hd,"0;33;40m");
  506.  
  507.  hd->HelpFile=Open(name,MODE_OLDFILE);
  508.  if(hd->HelpFile==NULL)
  509.   {
  510.    MultiRequest("Kann Hilfedatei nicht öffnen:",name,"Okay",NULL);
  511.    return(FALSE);
  512.   }
  513.  
  514.  hd->Pages=AllocMem(sizeof(struct Pages),MEMF_CLEAR|MEMF_PUBLIC);
  515.  if(hd->Pages==NULL)
  516.   {
  517.    ErrorRequest(ERROR_ALLOC);
  518.    return(FALSE);
  519.   }
  520.  
  521.  hd->Memory=AllocMem(50000,MEMF_CLEAR|MEMF_PUBLIC);
  522.  if(hd->Memory==NULL)
  523.   {
  524.    ErrorRequest(ERROR_ALLOC);
  525.    return(FALSE);
  526.   }
  527.  
  528.  Seek(hd->HelpFile,-4,OFFSET_END);
  529.  Read(hd->HelpFile,&b,4L);
  530.  Seek(hd->HelpFile,b,OFFSET_BEGINNING);
  531.  for(i=0;i<1000;i++)
  532.   {
  533.    Read(hd->HelpFile,&c,1L);
  534.    if(c!=0)
  535.     {
  536.      Read(hd->HelpFile,&a,2L);
  537.      Read(hd->HelpFile,&b,4L);
  538.      LENGTH(i)=a;
  539.      OFFSET(i)=b;
  540.      FLAGS(i)=c;
  541.      Read(hd->HelpFile,&b,4L);
  542.      TOFFSET(i)=b;
  543.      Read(hd->HelpFile,&b,4L);
  544.      GOFFSET(i)=b;
  545.     }
  546.   }
  547.  
  548.  hd->MenuStrip=BuildMenuStrip(hd->MainWindow,7,AUTOBACKPEN);
  549.  if(hd->MenuStrip==NULL)
  550.   {
  551.    InfoRequest("Kein Speicher für Menu!");
  552.    return(FALSE);
  553.   }
  554.  
  555.  hd->Page=12345;
  556.  LoadPage(hd,0);
  557.  return(TRUE);
  558. }
  559.  
  560.  
  561. VOID CloseHelp(hd)
  562.  struct HelpData *hd;
  563. {
  564.  
  565.  RemIndexGadgets(hd);
  566.  if(hd->MenuStrip) RemoveMenuStrip(hd->MenuStrip,TRUE);
  567.  if(hd->ConDev==0) CloseDevice(hd->ConReq);
  568.  if(hd->GadWindow) DeleteStdWindow(hd->GadWindow);
  569.  if(hd->TextWindow) DeleteStdWindow(hd->TextWindow);
  570.  if(hd->IndexWindow) DeleteStdWindow(hd->IndexWindow);
  571.  if(hd->MainWindow) DeleteStdWindow(hd->MainWindow);
  572.  if(hd->Screen) CloseScreen(hd->Screen);
  573.  if(hd->ConReq) DeleteExtIO(hd->ConReq);
  574.  if(hd->ConPort) DeletePort(hd->ConPort);
  575.  if(hd->Pages) FreeMem(hd->Pages,sizeof(struct Pages));
  576.  if(hd->Memory) FreeMem(hd->Memory,50000);
  577.  if(hd->OpalFont) CloseFont(hd->OpalFont);
  578.  if(hd->HelpFile) Close(hd->HelpFile);
  579. }
  580.  
  581.  
  582. VOID ConWrite(hd,text)
  583.  struct HelpData *hd;
  584.  UBYTE           *text;
  585. {
  586.  hd->ConReq->io_Data=text;
  587.  hd->ConReq->io_Length=strlen(text);
  588.  hd->ConReq->io_Command=CMD_WRITE;
  589.  SendIO(hd->ConReq);
  590. }
  591.  
  592.  
  593. VOID RefreshGadWindow(hd)
  594.  struct HelpData *hd;
  595. {
  596.  WORD i;
  597.  static struct NewWindow GadWindowDef=
  598.   {
  599.    0,238,640,15,
  600.    0,1,
  601.    GADGETUP|ACTIVEWINDOW,
  602.    NOCAREREFRESH|BORDERLESS,
  603.    NULL,NULL,NULL,NULL,NULL,
  604.    10,10,640,256,
  605.    CUSTOMSCREEN
  606.   };
  607.  
  608.  if(hd->GadWindow!=NULL)
  609.    DeleteStdWindow(hd->GadWindow);
  610.  GetTitle(hd,hd->Page);
  611.  DrawMNTextBorder(hd->MainWindow,320,10,310,12,hd->Memory);
  612.  
  613.  GadWindowDef.Screen=hd->Screen;
  614.  hd->GadWindow=OpenWindow(&GadWindowDef);
  615.  if(hd->GadWindow!=NULL)
  616.   {
  617.    SetFont(hd->GadWindow->RPort,hd->OpalFont);
  618.    hd->GadUserPort=hd->GadWindow->UserPort;
  619.    hd->GadWindowSM=(1L<<hd->GadUserPort->mp_SigBit);
  620.    for(i=0;i<=3;i++) hd->NextPage[i]=0xFFFF;
  621.  
  622.    if(hd->Page>0)
  623.     {
  624.      for(i=(hd->Page-1);i>=0;i--)
  625.        if(FLAGS(i)==PAGE_INDEX)
  626.         { hd->NextPage[0]=i; break; }
  627.     }
  628.  
  629.    if(hd->Page!=0) hd->NextPage[3]=0;
  630.    if(hd->Page<999)
  631.     {
  632.      for(i=(hd->Page+1);i<=999;i++)
  633.        if(FLAGS(i)==PAGE_INDEX)
  634.         { hd->NextPage[3]=i; break; }
  635.     }
  636.  
  637.    if(hd->Page>0)
  638.     {
  639.      for(i=(hd->Page-1);i>=0;i--)
  640.       {
  641.        if(FLAGS(i)!=0)
  642.         {
  643.          if(FLAGS(i)==PAGE_TEXT)
  644.            hd->NextPage[1]=i;
  645.          break;
  646.         }
  647.       }
  648.     }
  649.  
  650.    if(hd->Page<999)
  651.     {
  652.      for(i=(hd->Page+1);i<=999;i++)
  653.       {
  654.        if(FLAGS(i)!=0)
  655.         {
  656.          if(FLAGS(i)==PAGE_TEXT)
  657.            hd->NextPage[2]=i;
  658.          break;
  659.         }
  660.       }
  661.     }
  662.  
  663.    for(i=0;i<=3;i++)
  664.     {
  665.      if(hd->NextPage[i]!=0xFFFF)
  666.       {
  667.        GetTitle(hd,hd->NextPage[i]);
  668.        CreateMBoolGadget(hd->GadWindow,10+(i*155),1,150,12,hd->Memory,i);
  669.       }
  670.     }
  671.   }
  672.  else
  673.   {
  674.    hd->GadWindowSM=0;
  675.    hd->GadUserPort=NULL;
  676.   }
  677.  hd->WaitSM=hd->GadWindowSM+hd->MainWindowSM+hd->IndexWindowSM+hd->TextWindowSM;
  678. }
  679.  
  680.  
  681. VOID GetTitle(hd,p)
  682.  struct HelpData *hd;
  683.  LONG             p;
  684. { 
  685.  LONG i,o;
  686.  
  687.  i=OFFSET(p);
  688.  if(i!=0)
  689.   {
  690.    o=Seek(hd->HelpFile,i,OFFSET_BEGINNING);
  691.    Read(hd->HelpFile,hd->Memory,1024L);
  692.    Seek(hd->HelpFile,o,OFFSET_BEGINNING);
  693.   }
  694.  else hd->Memory[0]=0x00;
  695. }
  696.  
  697.  
  698. VOID LoadPage(hd,num)
  699.  struct HelpData *hd;
  700.  UWORD            num;
  701. {
  702.  
  703.  if(num==hd->Page) return;
  704.  if(OFFSET(num)!=0)
  705.   {
  706.    RemIndexGadgets(hd);
  707.    hd->Page=num;
  708.    hd->Flags=FLAGS(num);
  709.    switch(hd->Flags)
  710.     {
  711.      case PAGE_INDEX:
  712.        NewProp(hd,1);
  713.        ShowIndexPage(hd,num);
  714.       break;
  715.      case PAGE_TEXT:
  716.        ShowTextPage(hd,num);
  717.       break;
  718.     }
  719.   }
  720.  else
  721.   {
  722.    DisplayBeep(hd->Screen);
  723.    DisplayBeep(hd->Screen);
  724.   }
  725. }
  726.  
  727.  
  728. VOID ShowIndexPage(hd,num)
  729.  struct HelpData *hd;
  730.  UWORD            num;
  731. {
  732.  UBYTE *m;
  733.  LONG   i,j;
  734.  UWORD  x,y,w;
  735.  UWORD  wort;
  736.  UBYTE  c;
  737.  
  738.  x=15; y=11;
  739.  j=TOFFSET(num);
  740.  if(j!=0)
  741.   {
  742.    i=LENGTH(num);
  743.    Seek(hd->HelpFile,j,OFFSET_BEGINNING);
  744.    Read(hd->HelpFile,hd->Memory,i);
  745.  
  746.  /* ----- Testausgabe -------------------------------------------------- */
  747.    SetAPen(hd->IndexRastPort,3);
  748.    m=hd->Memory;
  749.    for(j=0;j<i;j++)
  750.     {
  751.      c=m[j];
  752.      if(c==0x00)
  753.       {
  754.        x=15;
  755.        y+=10;
  756.       }
  757.      else
  758.       {
  759.        Move(hd->IndexRastPort,x,y);
  760.        Text(hd->IndexRastPort,&c,1L);
  761.        x=x+TextLength(hd->IndexRastPort,&c,1L);
  762.       }
  763.     }
  764.   }
  765.  
  766.  /* ----- Gadgets ------------------------------------------------------ */
  767.  j=GOFFSET(num);
  768.  if(j!=0)
  769.   {
  770.    Seek(hd->HelpFile,j,OFFSET_BEGINNING);
  771.    j=0;
  772.    Read(hd->HelpFile,&wort,2L);
  773.    while((wort!=0xFFFF)&&(j<=63))
  774.     {
  775.      hd->IndexGadgetPages[j]=wort;
  776.      j++;
  777.      Read(hd->HelpFile,&wort,2L);
  778.     }
  779.    hd->IGPCount=j;
  780.  
  781.  
  782.   printf("Y: %ld\n",y);
  783.   hd->IGy=(195-y)/27;
  784.   hd->IGs=hd->IGPCount/hd->IGy;
  785.  
  786.   hd->IGw=((552-((hd->IGs-1)*5))/hd->IGs);
  787.  
  788.   printf("Gad/Spalte %ld\n",hd->IGy);
  789.   printf("Spalten    %ld\n",hd->IGs);
  790.   printf("Width      %ld\n",hd->IGw);
  791.  
  792.   x=15;
  793.   for(i=0;i<hd->IGPCount;i++)
  794.     {
  795.      if(hd->IndexGadgetPages[i]!=2000)
  796.       {
  797.        GetTitle(hd,hd->IndexGadgetPages[i]);
  798.        hd->IndexGadgets[i]=CreateMBoolGadget(hd->IndexWindow,x,y,hd->IGw,12,hd->Memory,i);
  799.        x+=hd->IGw+5;
  800.        if(x>550) { x=15; y+=15; }
  801.       }
  802.      else
  803.       {
  804.        if(x>15)
  805.         {
  806.          x=15; y+=15;
  807.         }
  808.        y+=10;
  809.       }
  810.     }
  811.   }
  812.  
  813.  /* ----- GadWindow öffnen --------------------------------------------- */
  814.  
  815.  WindowToFront(hd->IndexWindow);
  816.  RefreshGadWindow(hd);
  817.  MakeMenu(hd);
  818. }
  819.  
  820.  
  821. VOID ShowTextPage(hd,num)
  822.  struct HelpData *hd;
  823.  UWORD            num;
  824. {
  825.  UBYTE          *m;
  826.  UWORD           wort;
  827.  REGISTER UWORD  i,j,k;
  828.  REGISTER ULONG  o;
  829.  
  830.  hd->MenuPageCount=0;
  831.  o=GOFFSET(num);
  832.  if(o!=0)
  833.   {
  834.    Seek(hd->HelpFile,o,OFFSET_BEGINNING);
  835.    Read(hd->HelpFile,&wort,2L);
  836.    while((wort!=0xFFFF)&&(j<=24))
  837.     {
  838.      hd->MenuPages[hd->MenuPageCount]=wort;
  839.      hd->MenuPageCount++;
  840.      Read(hd->HelpFile,&wort,2L);
  841.     }
  842.    for(j=0;j<hd->MenuPageCount;j++)
  843.     {
  844.      if(hd->MenuPages[j]!=2000)
  845.       {
  846.        GetTitle(hd,hd->MenuPages[j]);
  847.        if((strlen(hd->Memory))>60) hd->Memory[59]=0x00;
  848.        strcpy(&hd->MenuNames[j],hd->Memory);
  849.       }
  850.     }
  851.   }
  852.  MakeMenu(hd);
  853.  
  854.  RefreshGadWindow(hd);
  855.  hd->CurrentLine=0xFFFF;
  856.  hd->LineCount=0;
  857.  for(i=0;i<2000;i++) hd->Lines[i]=NULL;
  858.  
  859.  j=LENGTH(num);
  860.  Seek(hd->HelpFile,TOFFSET(num),OFFSET_BEGINNING);
  861.  Read(hd->HelpFile,hd->Memory,j);
  862.  
  863.  i=0;
  864.  while(i<j)
  865.  {
  866.   hd->Lines[hd->LineCount]=&hd->Memory[i];
  867.   i+=(strlen(&hd->Memory[i])+1);
  868.   hd->LineCount++;
  869.  } 
  870.  
  871.  ShowPart(hd,0);
  872.  
  873.  if(hd->LineCount>ZEILEN)
  874.    hd->PropBody=hd->LineCount-ZEILEN;
  875.  else
  876.    hd->PropBody=1;
  877.  NewProp(hd,hd->PropBody);
  878.  WindowToFront(hd->TextWindow);
  879. }
  880.  
  881.  
  882. VOID ShowPart(hd,part)
  883.  struct HelpData *hd;
  884.  UWORD            part;
  885. {
  886.  UBYTE          s[6];
  887.  REGISTER BYTE  test;
  888.  REGISTER UWORD i,j,k;
  889.  
  890.  if(part==hd->CurrentLine) return;
  891.  
  892.  if(!(hd->LineCount<=ZEILEN))
  893.   {
  894.    if(part>(hd->LineCount-ZEILEN)) part=hd->LineCount-ZEILEN;
  895.  
  896.    /*  part            = Zeile, ab der gelistet werden soll
  897.        hd->CurrentLine = Zeile, ab der gelistet wird          */
  898.  
  899.    if(part>hd->CurrentLine)
  900.      { test=3; if(part-hd->CurrentLine>=ZEILEN) test=1; }
  901.    else if(part<hd->CurrentLine)
  902.      { test=4; if(hd->CurrentLine-part>=ZEILEN) test=1; }
  903.    else if(part==hd->CurrentLine)
  904.      { test=1; }
  905.  
  906.    switch(test)
  907.     {
  908.      case 1:
  909.        hd->CurrentLine=part;
  910.        ConWrite(hd,"\f");
  911.        for(i=part;i<part+ZEILEN;i++)
  912.         {
  913.          ConWrite(hd,hd->Lines[i]);
  914.          ConWrite(hd,"\n");
  915.         }
  916.       break;
  917.      case 3:
  918.        j=part-hd->CurrentLine;
  919.        k=hd->CurrentLine+ZEILEN;
  920.        for(i=k;i<(k+j);i++)
  921.         {
  922.          ConWrite(hd,hd->Lines[i]);
  923.          ConWrite(hd,"\n");
  924.         }
  925.        hd->CurrentLine+=j;
  926.       break;
  927.      case 4:
  928.        j=hd->CurrentLine-part;
  929.        k=hd->CurrentLine;
  930.        ConWrite(hd,"\x9b");
  931.        ConWrite(hd,"H");
  932.        for(i=(k-j);i<k;i++)
  933.         {
  934.          ConWrite(hd,"\x9b");
  935.          ConWrite(hd,"L");
  936.          ConWrite(hd,hd->Lines[i]);
  937.          ConWrite(hd,"\n");
  938.         }
  939.        sprintf(&s,"%ldH",(ZEILEN+1));
  940.        ConWrite(hd,"\x9b");
  941.        ConWrite(hd,&s);
  942.        ConWrite(hd,"\x9b");
  943.        ConWrite(hd,"M");
  944.        hd->CurrentLine-=j;
  945.       break;
  946.     }
  947.   }
  948.  else
  949.   {
  950.    ConWrite(hd,"\f");
  951.    for(i=0;i<hd->LineCount;i++)
  952.     {
  953.      ConWrite(hd,hd->Lines[i]);
  954.      ConWrite(hd,"\n");
  955.     }
  956.   }
  957. }
  958.  
  959.  
  960. VOID RemIndexGadgets(hd)
  961.  struct HelpData *hd;
  962. {
  963.  UBYTE          i;
  964.  struct Gadget *gad;
  965.  
  966.  for(i=0;i<64;i++)
  967.   {
  968.    gad=hd->IndexGadgets[i];
  969.    if(gad!=NULL)
  970.     {
  971.      RemoveGadget(hd->IndexWindow,gad);
  972.      hd->IndexGadgets[i]=NULL;
  973.      hd->IndexGadgetPages[i]=0;
  974.     }
  975.   }
  976.  if(hd->IndexWindow->UserData!=NULL)
  977.   {
  978.    FreeRemember(&hd->IndexWindow->UserData,TRUE);
  979.    hd->IndexWindow->UserData=NULL;
  980.   }
  981.  Move(hd->IndexRastPort,0,0);
  982.  ClearScreen(hd->IndexRastPort);
  983. }
  984.  
  985.  
  986. VOID NewProp(hd,v)
  987.  struct HelpData *hd;
  988.  UWORD            v;
  989. {
  990.  
  991.  ModifyProp(hd->PropGadget,hd->MainWindow,NULL,
  992.             AUTOKNOB|PROPBORDERLESS|FREEVERT,0,0,0,65535/v);
  993. }
  994.  
  995.  
  996.  
  997. struct MenuStrip
  998. {
  999.  struct Window   *Window;
  1000.  struct TextAttr  TextAttr;
  1001.  UBYTE            FrontPen;
  1002.  UBYTE            BackPen;
  1003.  
  1004.  struct Menu     *LastMenu;
  1005.  struct MenuItem *LastItem;
  1006.  struct MenuItem *LastSubItem;
  1007.  struct Remember *Remember;
  1008. };
  1009.  
  1010. /* MenuStrip Grundstruktur erstellen */
  1011. struct MenuStrip *BuildMenuStrip(win,fp,bp)
  1012.  struct Window   *win;
  1013.  UWORD            fp,bp;
  1014. {
  1015.  register struct MenuStrip *ms;
  1016.  register struct RastPort  *rp;
  1017.  
  1018.  ms=AllocMem(sizeof(struct MenuStrip),MEMF_CLEAR|MEMF_PUBLIC);
  1019.  if(ms!=NULL)
  1020.   {
  1021.    ms->Window=win;
  1022.    rp=win->RPort;
  1023.    ms->TextAttr.ta_Name=rp->Font->tf_Message.mn_Node.ln_Name;
  1024.    ms->TextAttr.ta_YSize=rp->Font->tf_YSize;
  1025.    ms->TextAttr.ta_Flags=rp->Font->tf_Flags;
  1026.    ms->TextAttr.ta_Style=rp->AlgoStyle;
  1027.    ms->FrontPen=fp;
  1028.    ms->BackPen=bp;
  1029.   }
  1030.  return(ms);
  1031. }
  1032.  
  1033. struct Menu *AddMenu(ms,x,w,name)
  1034.  struct MenuStrip *ms;
  1035.  UWORD             x,w;
  1036.  UBYTE            *name;
  1037. {
  1038.  register struct Menu *me;
  1039.  
  1040.  me=AllocRemember(&ms->Remember,sizeof(struct Menu),MEMF_CLEAR|MEMF_PUBLIC);
  1041.  if(me!=NULL)
  1042.   {
  1043.    me->LeftEdge=x;
  1044.    me->TopEdge=0;
  1045.    me->Width=w;
  1046.    me->Height=10;
  1047.    me->Flags=MENUENABLED;
  1048.    me->MenuName=name;
  1049.    me->NextMenu=ms->LastMenu;
  1050.    ms->LastMenu=me;
  1051.    ms->LastItem=NULL;
  1052.    ms->LastSubItem=NULL;
  1053.   }
  1054.  return(me);
  1055. }
  1056.  
  1057. struct MenuItem *AddItem(ms,name,w,cmd,enabled,highcomp)
  1058.  struct MenuStrip *ms;
  1059.  UBYTE            *name;
  1060.  UWORD             w;
  1061.  UBYTE             cmd;
  1062.  BOOL              enabled,highcomp;
  1063. {
  1064.  register struct Menu      *me;
  1065.  register struct MenuItem  *mi;
  1066.  register struct IntuiText *it;
  1067.  
  1068.  me=ms->LastMenu;
  1069.  if(me!=NULL)
  1070.   {
  1071.    mi=AllocRemember(&ms->Remember,sizeof(struct MenuItem)+sizeof(struct IntuiText),MEMF_CLEAR|MEMF_PUBLIC);
  1072.    if(mi!=NULL)
  1073.     {
  1074.      it=(ULONG)mi+(ULONG)sizeof(struct MenuItem);
  1075.  
  1076.      if(ms->LastItem!=NULL)
  1077.        mi->TopEdge=ms->LastItem->TopEdge+10;
  1078.      else
  1079.        mi->TopEdge=0;
  1080.      mi->LeftEdge=0;
  1081.      mi->Width=w;
  1082.      mi->Height=10;
  1083.      mi->Flags=ITEMTEXT;
  1084.      if(enabled) mi->Flags |= ITEMENABLED;
  1085.      if(highcomp) mi->Flags |= HIGHCOMP; else mi->Flags |= HIGHNONE;
  1086.      if(cmd!=0)
  1087.       {
  1088.        mi->Flags |= COMMSEQ;
  1089.        mi->Command=cmd;
  1090.       }
  1091.      mi->ItemFill=it;
  1092.      it->LeftEdge=AUTOLEFTEDGE;
  1093.      it->TopEdge=1;
  1094.      it->DrawMode=JAM1;
  1095.      it->FrontPen=ms->FrontPen;
  1096.      it->BackPen=ms->BackPen;
  1097.      it->ITextFont=&ms->TextAttr;
  1098.      it->IText=name;
  1099.      mi->NextItem=ms->LastItem;
  1100.      ms->LastItem=mi;
  1101.      ms->LastSubItem=NULL;
  1102.      me->FirstItem=mi;
  1103.     }
  1104.   }
  1105.  return(mi);
  1106. }
  1107.  
  1108. VOID UseMenuStrip(ms)
  1109.  struct MenuStrip *ms;
  1110. {
  1111.  
  1112.  if(ms->LastMenu!=NULL) SetMenuStrip(ms->Window,ms->LastMenu);
  1113. }
  1114.  
  1115. VOID RemoveMenuStrip(ms,bool)
  1116.  struct MenuStrip *ms;
  1117.  BOOL              bool;
  1118. {
  1119.  ClearMenuStrip(ms->Window);
  1120.  if(ms->Remember!=NULL) FreeRemember(&ms->Remember,TRUE);
  1121.  ms->Remember=NULL;
  1122.  ms->LastMenu=NULL;
  1123.  ms->LastItem=NULL;
  1124.  ms->LastSubItem=NULL;
  1125.  if(bool==TRUE) FreeMem(ms,sizeof(struct MenuStrip));
  1126. }
  1127.  
  1128. UBYTE *GetOpalLine()
  1129. {
  1130.  return((UBYTE *)"·········································································");
  1131. }
  1132.  
  1133. UBYTE *GetOpalLine450()
  1134. {
  1135.  return((UBYTE *)"·················································································································");
  1136. }
  1137.  
  1138. VOID MacFormat(hd,tex,x)
  1139.  struct HelpData *hd;
  1140.  UBYTE           *tex;
  1141.  UWORD            x;
  1142. {
  1143.  REGISTER UWORD i,j,k,l;
  1144.  
  1145.  k=strlen(tex);
  1146.  l=TextLength(hd->MainRastPort,tex,k);
  1147.  if(l>x)
  1148.   {
  1149.    i=0;
  1150.    j=TextLength(hd->MainRastPort,"...",3);
  1151.    l=j;
  1152.    do
  1153.     {
  1154.      j+=TextLength(hd->MainRastPort,&tex[i],1L);
  1155.      i++;
  1156.     } while(j<x);
  1157.    tex[i]=0x00;
  1158.    strcat(tex,"...");
  1159.   }
  1160. }
  1161.  
  1162.  
  1163. VOID MakeMenu(hd)
  1164.  struct HelpData *hd;
  1165. {
  1166.  REGISTER UWORD i,j;
  1167.  
  1168.  RemoveMenuStrip(hd->MenuStrip,FALSE);
  1169.  hd->DateiMenu=AddMenu(hd->MenuStrip,5,150,"Datei");
  1170.  AddItem(hd->MenuStrip,"Einstellunden ändern",300,'E',TRUE,TRUE);
  1171.  AddItem(hd->MenuStrip,"Bedienungshinweise",300,'B',TRUE,TRUE);
  1172.  AddItem(hd->MenuStrip,"Information",300,'I',TRUE,TRUE);
  1173.  AddItem(hd->MenuStrip,GetOpalLine(),300,0,FALSE,FALSE);
  1174.  AddItem(hd->MenuStrip,"Hilfe beenden",300,'Q',TRUE,TRUE);
  1175.  hd->QVMenu=AddMenu(hd->MenuStrip,160,150,"Querverweise");
  1176.  if((hd->Flags==PAGE_TEXT)&&(hd->MenuPageCount>0))
  1177.   {
  1178.    for(i=0;i<hd->MenuPageCount;i++)
  1179.     {
  1180.      if(hd->MenuPages[i]!=2000)
  1181.       {
  1182.        MacFormat(hd,&hd->MenuNames[i],430);
  1183.        AddItem(hd->MenuStrip,&hd->MenuNames[i],450,0,TRUE,TRUE);
  1184.       }
  1185.      else AddItem(hd->MenuStrip,GetOpalLine450(),450,0,FALSE,FALSE);
  1186.     }
  1187.   }
  1188.  else AddItem(hd->MenuStrip,"Nicht verfügbar",300,0,TRUE,FALSE);
  1189.  hd->BilderMenu=AddMenu(hd->MenuStrip,315,150,"Bilder");
  1190.  AddItem(hd->MenuStrip,"Nicht verfügbar",300,0,TRUE,FALSE);
  1191.  UseMenuStrip(hd->MenuStrip);
  1192.  ActivateWindow(hd->MainWindow);
  1193. }
  1194.  
  1195.  
  1196. VOID Hinweise(hd)
  1197.  struct HelpData *hd;
  1198. {
  1199.  REGISTER UWORD i;
  1200.  
  1201.  WindowToFront(hd->TextWindow);
  1202.  RemIndexGadgets(hd);
  1203.  hd->Flags=PAGE_TEXT;
  1204.  hd->Page=1001;
  1205.  hd->CurrentLine=0xFFFF;
  1206.  hd->LineCount=Strings;
  1207.  for(i=0;i<Strings;i++) hd->Lines[i]=String[i];
  1208.  for( ;i<2000;i++) hd->Lines[i]=NULL;
  1209.  ShowPart(hd,0);
  1210.  hd->PropBody=hd->LineCount-ZEILEN;
  1211.  NewProp(hd,hd->PropBody);
  1212.  WindowToFront(hd->TextWindow);
  1213. }
  1214.  
  1215.